/**
 * 翻译后端数据中的字段值
 * @param value - 后端传来的原始值
 * @param fieldType - 字段类型（如 'type', 'status', 'role' 等）
 * @param t - i18next 翻译函数
 * @param namespace - i18n 命名空间，默认为 'grade'
 * @returns 翻译后的值，如果找不到翻译则返回原值
 */
export const translateDataField = (
  value: string | number | undefined | null,
  fieldType: string,
  t: (key: string) => string,
  namespace: string = 'grade'
): string => {
  if (!value) return '';

  const stringValue = String(value);
  
  // 根据字段类型和值返回对应的翻译键
  const translationKey = getTranslationKey(stringValue, fieldType, namespace);
  
  if (translationKey) {
    // 根据翻译键的类型选择正确的命名空间
    let targetNamespace = namespace;
    
    // 状态字段的翻译键可能来自不同的命名空间
    if (fieldType === 'attendanceStatus') {
      targetNamespace = 'attendance';
    } else if (fieldType === 'studentStatus') {
      targetNamespace = 'student';
    } else if (fieldType === 'courseStatus') {
      targetNamespace = 'common';
    } else if (fieldType === 'gender' && (namespace === 'student' || namespace === 'dormitory')) {
      targetNamespace = namespace; // 学生和宿舍的性别使用各自的命名空间
    } else if (fieldType === 'genderType') {
      targetNamespace = 'dormitory';
    } else if (translationKey === 'activated' || translationKey === 'deactivated' || 
               translationKey === 'suspended' || translationKey === 'graduated' ||
               translationKey === 'ongoing' || translationKey === 'completed' || translationKey === 'upcoming') {
      targetNamespace = 'common'; // 通用状态使用 common 命名空间
    } else if (translationKey === 'present' || translationKey === 'late' || 
               translationKey === 'absent' || translationKey === 'leave') {
      targetNamespace = 'attendance'; // 考勤状态使用 attendance 命名空间
    }
    
    // 使用命名空间翻译
    try {
      const translated = t(`${targetNamespace}:${translationKey}`);
      // 如果翻译结果和键相同，说明没找到翻译，返回原值
      if (translated !== `${targetNamespace}:${translationKey}` && translated !== translationKey) {
        return translated;
      }
    } catch {
      // 忽略错误，继续尝试
    }
    
    // 如果使用命名空间失败，尝试不使用命名空间
    try {
      const translated = t(translationKey);
      if (translated !== translationKey) {
        return translated;
      }
    } catch {
      // 忽略错误
    }
    
    return stringValue;
  }
  
  return stringValue;
};

/**
 * 根据字段类型和值获取翻译键
 */
const getTranslationKey = (
  value: string,
  fieldType: string,
  namespace: string
): string | null => {
  // 成绩类型
  if (fieldType === 'examType' || fieldType === 'type') {
    const typeMap: Record<string, string> = {
      '月考': 'monthlyExam',
      '期中': 'midterm',
      '期末': 'final',
      'Monthly Exam': 'monthlyExam',
      'Midterm': 'midterm',
      'Final': 'final'
    };
    return typeMap[value] || null;
  }

  // 成绩状态
  if (fieldType === 'gradeStatus' || fieldType === 'status') {
    const statusMap: Record<string, string> = {
      'pass': 'pass',
      'fail': 'fail',
      'directPromotion': 'directPromotion',
      'notCounted': 'notCounted',
      '及格': 'pass',
      '不及格': 'fail',
      '直升': 'directPromotion',
      '不计数': 'notCounted',
      'Pass': 'pass',
      'Fail': 'fail',
      'Direct Promotion': 'directPromotion',
      'Not Counted': 'notCounted',
      'active': 'activated',
      'suspended': 'suspended',
      'graduated': 'graduated',
      'inactive': 'deactivated',
      'ongoing': 'ongoing',
      'completed': 'completed',
      'present': 'present',
      'late': 'late',
      'absent': 'absent',
      'leave': 'leave',
      // 中文状态值
      '在读': 'activated',
      '休学': 'suspended',
      '已毕业': 'graduated',
      '进行中': 'ongoing',
      '已完成': 'completed',
      '即将开始': 'upcoming',
      '出勤': 'present',
      '迟到': 'late',
      '缺勤': 'absent',
      '请假': 'leave'
    };
    return statusMap[value] || null;
  }

  // 用户角色
  if (fieldType === 'role') {
    const roleMap: Record<string, string> = {
      'admin': `common:admin`,
      'teacher': `common:teacher`,
      'student': `common:student`
    };
    return roleMap[value.toLowerCase()] || null;
  }

  // 性别
  if (fieldType === 'gender') {
    const lowerValue = String(value).toLowerCase();
    const genderMap: Record<string, string> = {
      'male': 'male',
      'female': 'female',
      'm': 'male',
      'f': 'female',
      '男': 'male',
      '女': 'female'
    };
    return genderMap[lowerValue] || null;
  }

  // 性别类型（宿舍用）
  if (fieldType === 'genderType') {
    const lowerValue = String(value).toLowerCase();
    const genderTypeMap: Record<string, string> = {
      'male': 'male',
      'female': 'female',
      '男生': 'male',
      '女生': 'female',
      '男生宿舍': 'male',
      '女生宿舍': 'female'
    };
    return genderTypeMap[lowerValue] || null;
  }

  // 课程状态
  if (fieldType === 'courseStatus') {
    const courseStatusMap: Record<string, string> = {
      'upcoming': 'upcoming',
      'ongoing': 'ongoing',
      'completed': 'completed',
      '即将开始': 'upcoming',
      '进行中': 'ongoing',
      '已完成': 'completed'
    };
    return courseStatusMap[value] || null;
  }

  // 学生状态
  if (fieldType === 'studentStatus') {
    const studentStatusMap: Record<string, string> = {
      'active': 'activated',
      'suspended': 'suspended',
      'graduated': 'graduated',
      '在读': 'activated',
      '休学': 'suspended',
      '已毕业': 'graduated'
    };
    return studentStatusMap[value] || null;
  }

  // 考勤状态
  if (fieldType === 'attendanceStatus') {
    const attendanceStatusMap: Record<string, string> = {
      'present': 'present',
      'late': 'late',
      'absent': 'absent',
      'leave': 'leave',
      '出勤': 'present',
      '迟到': 'late',
      '缺勤': 'absent',
      '请假': 'leave'
    };
    return attendanceStatusMap[value] || null;
  }

  return null;
};

/**
 * 批量翻译对象中的字段
 * @param data - 数据对象或数组
 * @param fieldsToTranslate - 需要翻译的字段配置 { fieldName: fieldType }
 * @param t - 翻译函数
 * @param namespace - 命名空间
 */
export const translateDataObject = <T extends Record<string, any>>(
  data: T | T[],
  fieldsToTranslate: Record<string, string>,
  t: (key: string) => string,
  namespace: string = 'grade'
): T | T[] => {
  if (Array.isArray(data)) {
    return data.map(item => translateDataObject(item, fieldsToTranslate, t, namespace) as T);
  }

  const translated = { ...data };
  
  Object.entries(fieldsToTranslate).forEach(([fieldName, fieldType]) => {
    if (translated[fieldName] !== undefined) {
      translated[fieldName] = translateDataField(
        translated[fieldName],
        fieldType,
        t,
        namespace
      );
    }
  });

  return translated;
};
